Termination of the following Term Rewriting System could not be shown:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The replacement map contains the following entries:

sel: {1, 2}
s: {1}
cons: {1}
0: empty set
first: {1, 2}
nil: empty set
from: {1}
sel1: {1, 2}
quote: empty set
first1: {1, 2}
nil1: empty set
cons1: {1, 2}
01: empty set
quote1: empty set
s1: {1}
unquote: {1}
unquote1: {1}
fcons: {1, 2}


↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Context-sensitive rewrite system:
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The replacement map contains the following entries:

sel: {1, 2}
s: {1}
cons: {1}
0: empty set
first: {1, 2}
nil: empty set
from: {1}
sel1: {1, 2}
quote: empty set
first1: {1, 2}
nil1: empty set
cons1: {1, 2}
01: empty set
quote1: empty set
s1: {1}
unquote: {1}
unquote1: {1}
fcons: {1, 2}

Using Improved CS-DPs we result in the following initial Q-CSDP problem.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons, SEL, SEL1, FIRST1, UNQUOTE, FCONS, UNQUOTE1, FIRST, FROM} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1, QUOTE, QUOTE1, U} are not replacing on any position.

The ordinary context-sensitive dependency pairs DPo are:

SEL(s(X), cons(Y, Z)) → SEL(X, Z)
SEL1(s(X), cons(Y, Z)) → SEL1(X, Z)
SEL1(0, cons(X, Z)) → QUOTE(X)
FIRST1(s(X), cons(Y, Z)) → QUOTE(Y)
FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)
QUOTE1(cons(X, Z)) → QUOTE(X)
QUOTE1(cons(X, Z)) → QUOTE1(Z)
QUOTE(s(X)) → QUOTE(X)
QUOTE(sel(X, Z)) → SEL1(X, Z)
QUOTE1(first(X, Z)) → FIRST1(X, Z)
UNQUOTE(s1(X)) → UNQUOTE(X)
UNQUOTE1(cons1(X, Z)) → FCONS(unquote(X), unquote1(Z))
UNQUOTE1(cons1(X, Z)) → UNQUOTE(X)
UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

The collapsing dependency pairs are DPc:

SEL(s(X), cons(Y, Z)) → Z
SEL1(s(X), cons(Y, Z)) → Z
FIRST1(s(X), cons(Y, Z)) → Z
QUOTE(sel(X, Z)) → X
QUOTE(sel(X, Z)) → Z
QUOTE1(first(X, Z)) → X
QUOTE1(first(X, Z)) → Z


The hidden terms of R are:

first(X, Z)
from(s(X))

Every hiding context is built from:

first on positions {1, 2}
s on positions {1}
from on positions {1}

Hence, the new unhiding pairs DPu are :

SEL(s(X), cons(Y, Z)) → U(Z)
SEL1(s(X), cons(Y, Z)) → U(Z)
FIRST1(s(X), cons(Y, Z)) → U(Z)
QUOTE(sel(X, Z)) → U(X)
QUOTE(sel(X, Z)) → U(Z)
QUOTE1(first(X, Z)) → U(X)
QUOTE1(first(X, Z)) → U(Z)
U(first(x_0, x_1)) → U(x_0)
U(first(x_0, x_1)) → U(x_1)
U(s(x_0)) → U(x_0)
U(from(x_0)) → U(x_0)
U(first(X, Z)) → FIRST(X, Z)
U(from(s(X))) → FROM(s(X))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

The approximation of the Context-Sensitive Dependency Graph contains 7 SCCs with 14 less nodes.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPSubtermProof
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1, U} are not replacing on any position.

The TRS P consists of the following rules:

U(first(x_0, x_1)) → U(x_0)
U(first(x_0, x_1)) → U(x_1)
U(s(x_0)) → U(x_0)
U(from(x_0)) → U(x_0)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


U(first(x_0, x_1)) → U(x_0)
U(first(x_0, x_1)) → U(x_1)
U(s(x_0)) → U(x_0)
U(from(x_0)) → U(x_0)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
U(x1)  =  x1

Subterm Order


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPSubtermProof
              ↳ QCSDP
                ↳ PIsEmptyProof
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSDPSubtermProof
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons, UNQUOTE} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


UNQUOTE(s1(X)) → UNQUOTE(X)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
UNQUOTE(x1)  =  x1

Subterm Order


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSDPSubtermProof
              ↳ QCSDP
                ↳ PIsEmptyProof
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSDPSubtermProof
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons, UNQUOTE1} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
UNQUOTE1(x1)  =  x1

Subterm Order


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSDPSubtermProof
              ↳ QCSDP
                ↳ PIsEmptyProof
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ ConvertedToQDPProblemProof
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons, SEL1} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1, QUOTE} are not replacing on any position.

The TRS P consists of the following rules:

SEL1(s(X), cons(Y, Z)) → SEL1(X, Z)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(s(X)) → QUOTE(X)
QUOTE(sel(X, Z)) → SEL1(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

Converted QDP Problem, but could not keep Q or minimality.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ ConvertedToQDPProblemProof
              ↳ QDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTE(sel(X, Z)) → SEL1(X, Z)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(X), cons(Y, Z)) → SEL1(X, Z)
QUOTE(s(X)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all (P,Q,R)-chains.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSDPSubtermProof
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons, FIRST1} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:

FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
FIRST1(x1, x2)  =  x1

Subterm Order


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSDPSubtermProof
              ↳ QCSDP
                ↳ PIsEmptyProof
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSUsableRulesProof
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1, QUOTE1} are not replacing on any position.

The TRS P consists of the following rules:

QUOTE1(cons(X, Z)) → QUOTE1(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

The following rules are not useable and can be deleted:

sel(s(x0), cons(x1, x2)) → sel(x0, x2)
sel(0, cons(x0, x1)) → x0
first(0, x0) → nil
first(s(x0), cons(x1, x2)) → cons(x1, first(x0, x2))
from(x0) → cons(x0, from(s(x0)))
sel1(s(x0), cons(x1, x2)) → sel1(x0, x2)
sel1(0, cons(x0, x1)) → quote(x0)
first1(0, x0) → nil1
first1(s(x0), cons(x1, x2)) → cons1(quote(x1), first1(x0, x2))
quote(0) → 01
quote1(cons(x0, x1)) → cons1(quote(x0), quote1(x1))
quote1(nil) → nil1
quote(s(x0)) → s1(quote(x0))
quote(sel(x0, x1)) → sel1(x0, x1)
quote1(first(x0, x1)) → first1(x0, x1)
unquote(01) → 0
unquote(s1(x0)) → s(unquote(x0))
unquote1(nil1) → nil
unquote1(cons1(x0, x1)) → fcons(unquote(x0), unquote1(x1))
fcons(x0, x1) → cons(x0, x1)


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSUsableRulesProof
              ↳ QCSDP
                ↳ QCSDPReductionPairProof
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {QUOTE1} are not replacing on any position.

The TRS P consists of the following rules:

QUOTE1(cons(X, Z)) → QUOTE1(Z)

R is empty.
Q is empty.

Using the order
Recursive path order with status [2].
Quasi-Precedence:
cons2 > QUOTE11

Status:
cons2: multiset
QUOTE11: multiset


the following usable rules
none

could all be oriented weakly.
Since all dependency pairs and these rules are strongly conservative, this is sound.
Furthermore, the pairs

QUOTE1(cons(X, Z)) → QUOTE1(Z)

could be oriented strictly and thus removed.
All pairs have been removed.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSUsableRulesProof
              ↳ QCSDP
                ↳ QCSDPReductionPairProof
                  ↳ QCSDP
                    ↳ PIsEmptyProof
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:

The TRS P consists of the following rules:
none

R is empty.
Q is empty.

The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSDPSubtermProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons, SEL} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → SEL(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


SEL(s(X), cons(Y, Z)) → SEL(X, Z)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
SEL(x1, x2)  =  x1

Subterm Order


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
          ↳ QCSDP
            ↳ QCSDPSubtermProof
              ↳ QCSDP
                ↳ PIsEmptyProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {sel, s, first, from, sel1, first1, cons1, s1, unquote, unquote1, fcons} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {quote, quote1} are not replacing on any position.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.
We applied the Incomplete Giesl Middeldorp transformation [11] to transform the context-sensitive TRS to a usual TRS.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
  ↳ Trivial-Transformation

Q restricted rewrite system:
The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(first(x1, x2)) → FIRSTACTIVE(mark(x1), mark(x2))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(cons(x1, x2)) → MARK(x1)
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first(x1, x2)) → MARK(x2)
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → SEL1ACTIVE(mark(x1), mark(x2))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2))
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(cons1(x1, x2)) → MARK(x1)
FROMACTIVE(X) → MARK(X)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(first(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(from(x1)) → MARK(x1)
MARK(quote(x1)) → QUOTEACTIVE(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(unquote1(x1)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(x1, x2)) → MARK(x2)

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(first(x1, x2)) → FIRSTACTIVE(mark(x1), mark(x2))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(cons(x1, x2)) → MARK(x1)
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first(x1, x2)) → MARK(x2)
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → SEL1ACTIVE(mark(x1), mark(x2))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2))
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(cons1(x1, x2)) → MARK(x1)
FROMACTIVE(X) → MARK(X)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(first(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(from(x1)) → MARK(x1)
MARK(quote(x1)) → QUOTEACTIVE(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(unquote1(x1)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(x1, x2)) → MARK(x2)

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2)) at position [0] we obtained the following new rules:

MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(cons1(x0, x1), y1)) → SELACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(sel(cons(x0, x1), y1)) → SELACTIVE(cons(mark(x0), x1), mark(y1))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(01, y1)) → SELACTIVE(01, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(nil, y1)) → SELACTIVE(nil, mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(nil1, y1)) → SELACTIVE(nil1, mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s1(x0), y1)) → SELACTIVE(s1(mark(x0)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(x1, x2)) → FIRSTACTIVE(mark(x1), mark(x2))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel(cons1(x0, x1), y1)) → SELACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(cons(x0, x1), y1)) → SELACTIVE(cons(mark(x0), x1), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(nil, y1)) → SELACTIVE(nil, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(nil1, y1)) → SELACTIVE(nil1, mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → SEL1ACTIVE(mark(x1), mark(x2))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(01, y1)) → SELACTIVE(01, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(s1(x0), y1)) → SELACTIVE(s1(mark(x0)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(from(x1)) → MARK(x1)
MARK(quote(x1)) → QUOTEACTIVE(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(x1, x2)) → MARK(x2)

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 6 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(first(x1, x2)) → FIRSTACTIVE(mark(x1), mark(x2))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → SEL1ACTIVE(mark(x1), mark(x2))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2))
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(cons1(x1, x2)) → MARK(x1)
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(first(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(from(x1)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(x1, x2)) → MARK(x2)

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(x1, x2)) → FIRSTACTIVE(mark(x1), mark(x2)) at position [0] we obtained the following new rules:

MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(0, y1)) → FIRSTACTIVE(0, mark(y1))
MARK(first(nil1, y1)) → FIRSTACTIVE(nil1, mark(y1))
MARK(first(cons(x0, x1), y1)) → FIRSTACTIVE(cons(mark(x0), x1), mark(y1))
MARK(first(01, y1)) → FIRSTACTIVE(01, mark(y1))
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first(nil, y1)) → FIRSTACTIVE(nil, mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s1(x0), y1)) → FIRSTACTIVE(s1(mark(x0)), mark(y1))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(cons1(x0, x1), y1)) → FIRSTACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTE1ACTIVE(first(X, Z)) → MARK(X)
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(0, y1)) → FIRSTACTIVE(0, mark(y1))
MARK(first(nil1, y1)) → FIRSTACTIVE(nil1, mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(first(cons(x0, x1), y1)) → FIRSTACTIVE(cons(mark(x0), x1), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → SEL1ACTIVE(mark(x1), mark(x2))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(nil, y1)) → FIRSTACTIVE(nil, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FROMACTIVE(X) → MARK(X)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(cons1(x0, x1), y1)) → FIRSTACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(from(x1)) → MARK(x1)
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(first(01, y1)) → FIRSTACTIVE(01, mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(first(s1(x0), y1)) → FIRSTACTIVE(s1(mark(x0)), mark(y1))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTE1ACTIVE(first(X, Z)) → MARK(X)
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → SEL1ACTIVE(mark(x1), mark(x2))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2))
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FROMACTIVE(X) → MARK(X)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(from(x1)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(x1, x2)) → SEL1ACTIVE(mark(x1), mark(x2)) at position [0] we obtained the following new rules:

MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(cons(x0, x1), y1)) → SEL1ACTIVE(cons(mark(x0), x1), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s1(x0), y1)) → SEL1ACTIVE(s1(mark(x0)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel1(cons1(x0, x1), y1)) → SEL1ACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
MARK(sel1(nil, y1)) → SEL1ACTIVE(nil, mark(y1))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(nil1, y1)) → SEL1ACTIVE(nil1, mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(01, y1)) → SEL1ACTIVE(01, mark(y1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s1(x0), y1)) → SEL1ACTIVE(s1(mark(x0)), mark(y1))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(nil, y1)) → SEL1ACTIVE(nil, mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(quote(x1)) → QUOTEACTIVE(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(01, y1)) → SEL1ACTIVE(01, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(cons(x0, x1), y1)) → SEL1ACTIVE(cons(mark(x0), x1), mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel1(nil1, y1)) → SEL1ACTIVE(nil1, mark(y1))
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel1(cons1(x0, x1), y1)) → SEL1ACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 6 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTE1ACTIVE(first(X, Z)) → MARK(X)
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2))
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(from(x1)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(x1, x2)) → FIRST1ACTIVE(mark(x1), mark(x2)) at position [0] we obtained the following new rules:

MARK(first1(cons(x0, x1), y1)) → FIRST1ACTIVE(cons(mark(x0), x1), mark(y1))
MARK(first1(01, y1)) → FIRST1ACTIVE(01, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first1(nil1, y1)) → FIRST1ACTIVE(nil1, mark(y1))
MARK(first1(0, y1)) → FIRST1ACTIVE(0, mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(s1(x0), y1)) → FIRST1ACTIVE(s1(mark(x0)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(nil, y1)) → FIRST1ACTIVE(nil, mark(y1))
MARK(first1(cons1(x0, x1), y1)) → FIRST1ACTIVE(cons1(mark(x0), mark(x1)), mark(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first1(cons(x0, x1), y1)) → FIRST1ACTIVE(cons(mark(x0), x1), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first1(0, y1)) → FIRST1ACTIVE(0, mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(first1(nil1, y1)) → FIRST1ACTIVE(nil1, mark(y1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(first1(nil, y1)) → FIRST1ACTIVE(nil, mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(quote(x1)) → QUOTEACTIVE(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
MARK(first1(cons1(x0, x1), y1)) → FIRST1ACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(s1(x0), y1)) → FIRST1ACTIVE(s1(mark(x0)), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(01, y1)) → FIRST1ACTIVE(01, mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(from(x1)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTEACTIVE(sel(X, Z)) → SEL1ACTIVE(mark(X), mark(Z)) at position [0] we obtained the following new rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(01, y1)) → SEL1ACTIVE(01, mark(y1))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(nil1, y1)) → SEL1ACTIVE(nil1, mark(y1))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(cons1(x0, x1), y1)) → SEL1ACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(nil, y1)) → SEL1ACTIVE(nil, mark(y1))
QUOTEACTIVE(sel(s1(x0), y1)) → SEL1ACTIVE(s1(mark(x0)), mark(y1))
QUOTEACTIVE(sel(cons(x0, x1), y1)) → SEL1ACTIVE(cons(mark(x0), x1), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(01, y1)) → SEL1ACTIVE(01, mark(y1))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(cons(x0, x1), y1)) → SEL1ACTIVE(cons(mark(x0), x1), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(quote(x1)) → QUOTEACTIVE(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
SELACTIVE(0, cons(X, Z)) → MARK(X)
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(s1(x0), y1)) → SEL1ACTIVE(s1(mark(x0)), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(nil, y1)) → SEL1ACTIVE(nil, mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
QUOTEACTIVE(sel(nil1, y1)) → SEL1ACTIVE(nil1, mark(y1))
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
QUOTEACTIVE(sel(cons1(x0, x1), y1)) → SEL1ACTIVE(cons1(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 6 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(from(x1)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(unquote(x1)) → UNQUOTEACTIVE(mark(x1)) at position [0] we obtained the following new rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(01)) → UNQUOTEACTIVE(01)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(unquote(cons1(x0, x1))) → UNQUOTEACTIVE(cons1(mark(x0), mark(x1)))
MARK(unquote(s(x0))) → UNQUOTEACTIVE(s(mark(x0)))
MARK(unquote(0)) → UNQUOTEACTIVE(0)
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote(nil1)) → UNQUOTEACTIVE(nil1)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(unquote(cons(x0, x1))) → UNQUOTEACTIVE(cons(mark(x0), x1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(unquote(nil)) → UNQUOTEACTIVE(nil)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(unquote(s(x0))) → UNQUOTEACTIVE(s(mark(x0)))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(nil)) → UNQUOTEACTIVE(nil)
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
SELACTIVE(0, cons(X, Z)) → MARK(X)
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
MARK(unquote(0)) → UNQUOTEACTIVE(0)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(unquote(nil1)) → UNQUOTEACTIVE(nil1)
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(cons1(x0, x1))) → UNQUOTEACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(cons(x0, x1))) → UNQUOTEACTIVE(cons(mark(x0), x1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(unquote(01)) → UNQUOTEACTIVE(01)
MARK(from(x1)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(unquote1(x1)) → UNQUOTE1ACTIVE(mark(x1)) at position [0] we obtained the following new rules:

MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(unquote1(0)) → UNQUOTE1ACTIVE(0)
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(unquote1(nil1)) → UNQUOTE1ACTIVE(nil1)
MARK(unquote1(cons(x0, x1))) → UNQUOTE1ACTIVE(cons(mark(x0), x1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(unquote1(s1(x0))) → UNQUOTE1ACTIVE(s1(mark(x0)))
MARK(unquote1(01)) → UNQUOTE1ACTIVE(01)
MARK(unquote1(s(x0))) → UNQUOTE1ACTIVE(s(mark(x0)))
MARK(unquote1(nil)) → UNQUOTE1ACTIVE(nil)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(nil1)) → UNQUOTE1ACTIVE(nil1)
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(s(x0))) → UNQUOTE1ACTIVE(s(mark(x0)))
MARK(unquote1(01)) → UNQUOTE1ACTIVE(01)
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(unquote1(0)) → UNQUOTE1ACTIVE(0)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(s1(x0))) → UNQUOTE1ACTIVE(s1(mark(x0)))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(nil)) → UNQUOTE1ACTIVE(nil)
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(unquote1(cons(x0, x1))) → UNQUOTE1ACTIVE(cons(mark(x0), x1))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(unquote(x0), y1)) → SELACTIVE(unquoteActive(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), nil1)) → SELACTIVE(unquoteActive(mark(y0)), nil1)
MARK(sel(unquote(y0), 01)) → SELACTIVE(unquoteActive(mark(y0)), 01)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), s(x0))) → SELACTIVE(unquoteActive(mark(y0)), s(mark(x0)))
MARK(sel(unquote(y0), s1(x0))) → SELACTIVE(unquoteActive(mark(y0)), s1(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), 0)) → SELACTIVE(unquoteActive(mark(y0)), 0)
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), cons1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel(unquote(y0), nil)) → SELACTIVE(unquoteActive(mark(y0)), nil)
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), cons1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote(y0), s1(x0))) → SELACTIVE(unquoteActive(mark(y0)), s1(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(unquote(y0), 01)) → SELACTIVE(unquoteActive(mark(y0)), 01)
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(unquote(y0), s(x0))) → SELACTIVE(unquoteActive(mark(y0)), s(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), nil1)) → SELACTIVE(unquoteActive(mark(y0)), nil1)
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote(y0), 0)) → SELACTIVE(unquoteActive(mark(y0)), 0)
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), nil)) → SELACTIVE(unquoteActive(mark(y0)), nil)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(quote(x0), y1)) → SELACTIVE(quoteActive(x0), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), nil)) → SELACTIVE(quoteActive(y0), nil)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons1(x0, x1))) → SELACTIVE(quoteActive(y0), cons1(mark(x0), mark(x1)))
MARK(sel(quote(y0), s1(x0))) → SELACTIVE(quoteActive(y0), s1(mark(x0)))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(quote(y0), 0)) → SELACTIVE(quoteActive(y0), 0)
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(quote(y0), 01)) → SELACTIVE(quoteActive(y0), 01)
MARK(sel(quote(y0), nil1)) → SELACTIVE(quoteActive(y0), nil1)
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote(y0), s(x0))) → SELACTIVE(quoteActive(y0), s(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(quote(y0), 01)) → SELACTIVE(quoteActive(y0), 01)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), nil1)) → SELACTIVE(quoteActive(y0), nil1)
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel(quote(y0), nil)) → SELACTIVE(quoteActive(y0), nil)
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(quote(y0), s1(x0))) → SELACTIVE(quoteActive(y0), s1(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), 0)) → SELACTIVE(quoteActive(y0), 0)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(s1(x1)) → MARK(x1)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), cons1(x0, x1))) → SELACTIVE(quoteActive(y0), cons1(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(quote(y0), s(x0))) → SELACTIVE(quoteActive(y0), s(mark(x0)))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(s1(x1)) → MARK(x1)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(s(x0), y1)) → SELACTIVE(s(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), s1(x0))) → SELACTIVE(s(mark(y0)), s1(mark(x0)))
MARK(sel(s(y0), 0)) → SELACTIVE(s(mark(y0)), 0)
MARK(sel(s(y0), cons1(x0, x1))) → SELACTIVE(s(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), nil1)) → SELACTIVE(s(mark(y0)), nil1)
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), s(x0))) → SELACTIVE(s(mark(y0)), s(mark(x0)))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), 01)) → SELACTIVE(s(mark(y0)), 01)
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), nil)) → SELACTIVE(s(mark(y0)), nil)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), nil)) → SELACTIVE(s(mark(y0)), nil)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(sel(s(y0), cons1(x0, x1))) → SELACTIVE(s(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(s(y0), nil1)) → SELACTIVE(s(mark(y0)), nil1)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), 0)) → SELACTIVE(s(mark(y0)), 0)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), 01)) → SELACTIVE(s(mark(y0)), 01)
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(s(y0), s1(x0))) → SELACTIVE(s(mark(y0)), s1(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), s(x0))) → SELACTIVE(s(mark(y0)), s(mark(x0)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(first1(x0, x1), y1)) → SELACTIVE(first1Active(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), s1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), nil)) → SELACTIVE(first1Active(mark(y0), mark(y1)), nil)
MARK(sel(first1(y0, y1), 01)) → SELACTIVE(first1Active(mark(y0), mark(y1)), 01)
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first1(y0, y1), nil1)) → SELACTIVE(first1Active(mark(y0), mark(y1)), nil1)
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), s(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(first1(y0, y1), 0)) → SELACTIVE(first1Active(mark(y0), mark(y1)), 0)
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), cons1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), s1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), 01)) → SELACTIVE(first1Active(mark(y0), mark(y1)), 01)
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), 0)) → SELACTIVE(first1Active(mark(y0), mark(y1)), 0)
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), s(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(first1(y0, y1), nil)) → SELACTIVE(first1Active(mark(y0), mark(y1)), nil)
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), nil1)) → SELACTIVE(first1Active(mark(y0), mark(y1)), nil1)
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), cons1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(x1, x2)) → MARK(x1)
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(sel1(x0, x1), y1)) → SELACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), 01)) → SELACTIVE(sel1Active(mark(y0), mark(y1)), 01)
MARK(sel(sel1(y0, y1), s1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), nil)) → SELACTIVE(sel1Active(mark(y0), mark(y1)), nil)
MARK(sel(sel1(y0, y1), cons1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), nil1)) → SELACTIVE(sel1Active(mark(y0), mark(y1)), nil1)
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), s(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), 0)) → SELACTIVE(sel1Active(mark(y0), mark(y1)), 0)
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(sel1(y0, y1), 01)) → SELACTIVE(sel1Active(mark(y0), mark(y1)), 01)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(sel1(y0, y1), nil)) → SELACTIVE(sel1Active(mark(y0), mark(y1)), nil)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), cons1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(sel1(y0, y1), s(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(fcons(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel(sel1(y0, y1), s1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), nil1)) → SELACTIVE(sel1Active(mark(y0), mark(y1)), nil1)
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), 0)) → SELACTIVE(sel1Active(mark(y0), mark(y1)), 0)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(from(x0), y1)) → SELACTIVE(fromActive(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), nil)) → SELACTIVE(fromActive(mark(y0)), nil)
MARK(sel(from(y0), 01)) → SELACTIVE(fromActive(mark(y0)), 01)
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), s(x0))) → SELACTIVE(fromActive(mark(y0)), s(mark(x0)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), cons1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel(from(y0), nil1)) → SELACTIVE(fromActive(mark(y0)), nil1)
MARK(sel(from(y0), 0)) → SELACTIVE(fromActive(mark(y0)), 0)
MARK(sel(from(y0), s1(x0))) → SELACTIVE(fromActive(mark(y0)), s1(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(from(y0), s(x0))) → SELACTIVE(fromActive(mark(y0)), s(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), 0)) → SELACTIVE(fromActive(mark(y0)), 0)
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), nil)) → SELACTIVE(fromActive(mark(y0)), nil)
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(from(y0), cons1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(from(y0), 01)) → SELACTIVE(fromActive(mark(y0)), 01)
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), s1(x0))) → SELACTIVE(fromActive(mark(y0)), s1(mark(x0)))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), nil1)) → SELACTIVE(fromActive(mark(y0)), nil1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
FROMACTIVE(X) → MARK(X)
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(x1, x2)) → MARK(x1)
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(unquote1(x0), y1)) → SELACTIVE(unquote1Active(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), s1(x0))) → SELACTIVE(unquote1Active(mark(y0)), s1(mark(x0)))
MARK(sel(unquote1(y0), nil)) → SELACTIVE(unquote1Active(mark(y0)), nil)
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), 01)) → SELACTIVE(unquote1Active(mark(y0)), 01)
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote1(y0), nil1)) → SELACTIVE(unquote1Active(mark(y0)), nil1)
MARK(sel(unquote1(y0), s(x0))) → SELACTIVE(unquote1Active(mark(y0)), s(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), 0)) → SELACTIVE(unquote1Active(mark(y0)), 0)
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), s(x0))) → SELACTIVE(unquote1Active(mark(y0)), s(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(unquote1(y0), nil1)) → SELACTIVE(unquote1Active(mark(y0)), nil1)
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), 0)) → SELACTIVE(unquote1Active(mark(y0)), 0)
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), s1(x0))) → SELACTIVE(unquote1Active(mark(y0)), s1(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(unquote1(y0), 01)) → SELACTIVE(unquote1Active(mark(y0)), 01)
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), nil)) → SELACTIVE(unquote1Active(mark(y0)), nil)
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons1(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(fcons(x0, x1), y1)) → SELACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), nil)) → SELACTIVE(fconsActive(mark(y0), mark(y1)), nil)
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), s(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(fcons(y0, y1), cons1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), nil1)) → SELACTIVE(fconsActive(mark(y0), mark(y1)), nil1)
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), s1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), 0)) → SELACTIVE(fconsActive(mark(y0), mark(y1)), 0)
MARK(sel(fcons(y0, y1), 01)) → SELACTIVE(fconsActive(mark(y0), mark(y1)), 01)
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), nil1)) → SELACTIVE(fconsActive(mark(y0), mark(y1)), nil1)
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), nil)) → SELACTIVE(fconsActive(mark(y0), mark(y1)), nil)
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(sel(fcons(y0, y1), 01)) → SELACTIVE(fconsActive(mark(y0), mark(y1)), 01)
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), 0)) → SELACTIVE(fconsActive(mark(y0), mark(y1)), 0)
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(fcons(y0, y1), s(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), s1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), s1(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(first(x0, x1), y1)) → SELACTIVE(firstActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(first(y0, y1), nil)) → SELACTIVE(firstActive(mark(y0), mark(y1)), nil)
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first(y0, y1), 01)) → SELACTIVE(firstActive(mark(y0), mark(y1)), 01)
MARK(sel(first(y0, y1), s(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(first(y0, y1), nil1)) → SELACTIVE(firstActive(mark(y0), mark(y1)), nil1)
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), 0)) → SELACTIVE(firstActive(mark(y0), mark(y1)), 0)
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), s1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), s1(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), 01)) → SELACTIVE(firstActive(mark(y0), mark(y1)), 01)
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), nil)) → SELACTIVE(firstActive(mark(y0), mark(y1)), nil)
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first(y0, y1), s(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), nil1)) → SELACTIVE(firstActive(mark(y0), mark(y1)), nil1)
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), 0)) → SELACTIVE(firstActive(mark(y0), mark(y1)), 0)
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first(y0, y1), cons1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(first(y0, y1), s1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(sel(x0, x1), y1)) → SELACTIVE(selActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), s(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(sel(y0, y1), 0)) → SELACTIVE(selActive(mark(y0), mark(y1)), 0)
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), s1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel(sel(y0, y1), 01)) → SELACTIVE(selActive(mark(y0), mark(y1)), 01)
MARK(sel(sel(y0, y1), nil1)) → SELACTIVE(selActive(mark(y0), mark(y1)), nil1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), cons1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), nil)) → SELACTIVE(selActive(mark(y0), mark(y1)), nil)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(sel(y0, y1), 0)) → SELACTIVE(selActive(mark(y0), mark(y1)), 0)
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), 01)) → SELACTIVE(selActive(mark(y0), mark(y1)), 01)
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(sel(y0, y1), nil1)) → SELACTIVE(selActive(mark(y0), mark(y1)), nil1)
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), nil)) → SELACTIVE(selActive(mark(y0), mark(y1)), nil)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), s(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), s1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), s1(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, y1)) → SELACTIVE(0, mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(0, y1)) → SELACTIVE(0, mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(0, cons1(x0, x1))) → SELACTIVE(0, cons1(mark(x0), mark(x1)))
MARK(sel(0, s(x0))) → SELACTIVE(0, s(mark(x0)))
MARK(sel(0, nil1)) → SELACTIVE(0, nil1)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(sel(0, 01)) → SELACTIVE(0, 01)
MARK(sel(0, s1(x0))) → SELACTIVE(0, s1(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(0, 0)) → SELACTIVE(0, 0)
MARK(sel(0, nil)) → SELACTIVE(0, nil)
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(0, s(x0))) → SELACTIVE(0, s(mark(x0)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(0, cons1(x0, x1))) → SELACTIVE(0, cons1(mark(x0), mark(x1)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(0, nil1)) → SELACTIVE(0, nil1)
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, 0)) → SELACTIVE(0, 0)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, s1(x0))) → SELACTIVE(0, s1(mark(x0)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(sel(0, 01)) → SELACTIVE(0, 01)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(0, nil)) → SELACTIVE(0, nil)
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel(quote1(x0), y1)) → SELACTIVE(quote1Active(x0), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel(quote1(y0), s1(x0))) → SELACTIVE(quote1Active(y0), s1(mark(x0)))
MARK(sel(quote1(y0), nil1)) → SELACTIVE(quote1Active(y0), nil1)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), s(x0))) → SELACTIVE(quote1Active(y0), s(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), 01)) → SELACTIVE(quote1Active(y0), 01)
MARK(sel(quote1(y0), cons1(x0, x1))) → SELACTIVE(quote1Active(y0), cons1(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), nil)) → SELACTIVE(quote1Active(y0), nil)
MARK(sel(quote1(y0), 0)) → SELACTIVE(quote1Active(y0), 0)
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), 01)) → SELACTIVE(quote1Active(y0), 01)
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(quote1(y0), 0)) → SELACTIVE(quote1Active(y0), 0)
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), s(x0))) → SELACTIVE(quote1Active(y0), s(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons1(x0, x1))) → SELACTIVE(quote1Active(y0), cons1(mark(x0), mark(x1)))
MARK(sel(quote1(y0), nil)) → SELACTIVE(quote1Active(y0), nil)
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), s1(x0))) → SELACTIVE(quote1Active(y0), s1(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), nil1)) → SELACTIVE(quote1Active(y0), nil1)
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(from(x0), y1)) → FIRSTACTIVE(fromActive(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(from(y0), s(x0))) → FIRSTACTIVE(fromActive(mark(y0)), s(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(from(y0), s1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), s1(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), nil)) → FIRSTACTIVE(fromActive(mark(y0)), nil)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), cons1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first(from(y0), 0)) → FIRSTACTIVE(fromActive(mark(y0)), 0)
MARK(first(from(y0), 01)) → FIRSTACTIVE(fromActive(mark(y0)), 01)
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), nil1)) → FIRSTACTIVE(fromActive(mark(y0)), nil1)
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(from(y0), nil1)) → FIRSTACTIVE(fromActive(mark(y0)), nil1)
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(from(y0), 01)) → FIRSTACTIVE(fromActive(mark(y0)), 01)
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), s(x0))) → FIRSTACTIVE(fromActive(mark(y0)), s(mark(x0)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(from(y0), s1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), s1(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(from(y0), cons1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(from(y0), 0)) → FIRSTACTIVE(fromActive(mark(y0)), 0)
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first(from(y0), nil)) → FIRSTACTIVE(fromActive(mark(y0)), nil)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(quote(x0), y1)) → FIRSTACTIVE(quoteActive(x0), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons1(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), nil1)) → FIRSTACTIVE(quoteActive(y0), nil1)
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), 0)) → FIRSTACTIVE(quoteActive(y0), 0)
MARK(first(quote(y0), 01)) → FIRSTACTIVE(quoteActive(y0), 01)
MARK(first(quote(y0), s1(x0))) → FIRSTACTIVE(quoteActive(y0), s1(mark(x0)))
MARK(first(quote(y0), s(x0))) → FIRSTACTIVE(quoteActive(y0), s(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), nil)) → FIRSTACTIVE(quoteActive(y0), nil)
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote(y0), 01)) → FIRSTACTIVE(quoteActive(y0), 01)
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote(y0), s1(x0))) → FIRSTACTIVE(quoteActive(y0), s1(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(first(quote(y0), nil)) → FIRSTACTIVE(quoteActive(y0), nil)
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), 0)) → FIRSTACTIVE(quoteActive(y0), 0)
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote(y0), cons1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons1(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), s(x0))) → FIRSTACTIVE(quoteActive(y0), s(mark(x0)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), nil1)) → FIRSTACTIVE(quoteActive(y0), nil1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(first1(x0, x1), y1)) → FIRSTACTIVE(first1Active(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), 0)) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), 0)
MARK(first(first1(y0, y1), 01)) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), 01)
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), nil1)) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), nil1)
MARK(first(first1(y0, y1), nil)) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), nil)
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), s1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), s(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), s(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), 0)) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), 0)
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), nil)) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), nil)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), s1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(first1(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), 01)) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), 01)
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first1(y0, y1), nil1)) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), nil1)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(quote1(x0), y1)) → FIRSTACTIVE(quote1Active(x0), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), 0)) → FIRSTACTIVE(quote1Active(y0), 0)
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), nil1)) → FIRSTACTIVE(quote1Active(y0), nil1)
MARK(first(quote1(y0), s(x0))) → FIRSTACTIVE(quote1Active(y0), s(mark(x0)))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(quote1(y0), s1(x0))) → FIRSTACTIVE(quote1Active(y0), s1(mark(x0)))
MARK(first(quote1(y0), nil)) → FIRSTACTIVE(quote1Active(y0), nil)
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons1(mark(x0), mark(x1)))
MARK(first(quote1(y0), 01)) → FIRSTACTIVE(quote1Active(y0), 01)
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), 01)) → FIRSTACTIVE(quote1Active(y0), 01)
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(first(quote1(y0), cons1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons1(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), s1(x0))) → FIRSTACTIVE(quote1Active(y0), s1(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), 0)) → FIRSTACTIVE(quote1Active(y0), 0)
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first(quote1(y0), nil)) → FIRSTACTIVE(quote1Active(y0), nil)
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), nil1)) → FIRSTACTIVE(quote1Active(y0), nil1)
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(first(quote1(y0), s(x0))) → FIRSTACTIVE(quote1Active(y0), s(mark(x0)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(unquote(x0), y1)) → FIRSTACTIVE(unquoteActive(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), nil1)) → FIRSTACTIVE(unquoteActive(mark(y0)), nil1)
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), s(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), s(mark(x0)))
MARK(first(unquote(y0), s1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), s1(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), nil)) → FIRSTACTIVE(unquoteActive(mark(y0)), nil)
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(unquote(y0), 01)) → FIRSTACTIVE(unquoteActive(mark(y0)), 01)
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), 0)) → FIRSTACTIVE(unquoteActive(mark(y0)), 0)
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(first(unquote(y0), cons1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(unquote(y0), nil)) → FIRSTACTIVE(unquoteActive(mark(y0)), nil)
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(unquote(y0), s1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), s1(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), 01)) → FIRSTACTIVE(unquoteActive(mark(y0)), 01)
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), s(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), s(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first(unquote(y0), 0)) → FIRSTACTIVE(unquoteActive(mark(y0)), 0)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), nil1)) → FIRSTACTIVE(unquoteActive(mark(y0)), nil1)
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(first(x0, x1), y1)) → FIRSTACTIVE(firstActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(first(y0, y1), s(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), 0)) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), 0)
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first(y0, y1), s1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(first(y0, y1), 01)) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), 01)
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), nil1)) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), nil1)
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), nil)) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), nil)
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(first(first(y0, y1), 01)) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), 01)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), nil1)) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), nil1)
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), s(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), 0)) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), 0)
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), nil)) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), nil)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), s1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), s1(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(sel(x0, x1), y1)) → FIRSTACTIVE(selActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(sel(y0, y1), 01)) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), 01)
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), s(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), s1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(sel(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel(y0, y1), 0)) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), 0)
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), nil)) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), nil)
MARK(first(sel(y0, y1), nil1)) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), nil1)
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(sel(y0, y1), nil1)) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), nil1)
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), s(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), s1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), 01)) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), 01)
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first(sel(y0, y1), 0)) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), 0)
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first(sel(y0, y1), nil)) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), nil)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(sel1(x0, x1), y1)) → FIRSTACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), nil)) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), nil)
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), nil1)) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), nil1)
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel1(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), 0)) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), 0)
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), s(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel1(y0, y1), s1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), 01)) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), 01)
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(first(sel1(y0, y1), nil1)) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), nil1)
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), s(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(sel1(y0, y1), s1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first(sel1(y0, y1), nil)) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), nil)
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(sel1(y0, y1), 0)) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), 0)
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), 01)) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), 01)
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(fcons(x0, x1), y1)) → FIRSTACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(fcons(y0, y1), nil)) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), nil)
MARK(first(fcons(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), s(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(fcons(y0, y1), nil1)) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), nil1)
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), s1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), 01)) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), 01)
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), 0)) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), 0)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), s(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), cons1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), s1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), 01)) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), 01)
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), 0)) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), 0)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(first(fcons(y0, y1), nil)) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), nil)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(fcons(y0, y1), nil1)) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), nil1)
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(unquote1(x0), y1)) → FIRSTACTIVE(unquote1Active(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(y0), s(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), s(mark(x0)))
MARK(first(unquote1(y0), 0)) → FIRSTACTIVE(unquote1Active(mark(y0)), 0)
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), nil)) → FIRSTACTIVE(unquote1Active(mark(y0)), nil)
MARK(first(unquote1(y0), s1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), s1(mark(x0)))
MARK(first(unquote1(y0), 01)) → FIRSTACTIVE(unquote1Active(mark(y0)), 01)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(unquote1(y0), cons1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote1(y0), nil1)) → FIRSTACTIVE(unquote1Active(mark(y0)), nil1)
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(unquote1(y0), s1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), s1(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), nil1)) → FIRSTACTIVE(unquote1Active(mark(y0)), nil1)
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(unquote1(y0), cons1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(first(unquote1(y0), 0)) → FIRSTACTIVE(unquote1Active(mark(y0)), 0)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), nil)) → FIRSTACTIVE(unquote1Active(mark(y0)), nil)
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), s(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), s(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote1(y0), 01)) → FIRSTACTIVE(unquote1Active(mark(y0)), 01)
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first(s(x0), y1)) → FIRSTACTIVE(s(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(s(y0), 0)) → FIRSTACTIVE(s(mark(y0)), 0)
MARK(first(s(y0), nil)) → FIRSTACTIVE(s(mark(y0)), nil)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(s(y0), nil1)) → FIRSTACTIVE(s(mark(y0)), nil1)
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(s(y0), 01)) → FIRSTACTIVE(s(mark(y0)), 01)
MARK(first(s(y0), cons1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first(s(y0), s1(x0))) → FIRSTACTIVE(s(mark(y0)), s1(mark(x0)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(s(y0), s(x0))) → FIRSTACTIVE(s(mark(y0)), s(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first(s(y0), 01)) → FIRSTACTIVE(s(mark(y0)), 01)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(s(y0), s1(x0))) → FIRSTACTIVE(s(mark(y0)), s1(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), 0)) → FIRSTACTIVE(s(mark(y0)), 0)
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(s(y0), cons1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first(s(y0), nil)) → FIRSTACTIVE(s(mark(y0)), nil)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), nil1)) → FIRSTACTIVE(s(mark(y0)), nil1)
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(s(y0), s(x0))) → FIRSTACTIVE(s(mark(y0)), s(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), nil)) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), nil)
MARK(sel1(first(y0, y1), 01)) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), 01)
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), s1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), nil1)) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), nil1)
MARK(sel1(first(y0, y1), 0)) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), 0)
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), s(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), s(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(first(y0, y1), s(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first(y0, y1), nil)) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), nil)
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), 0)) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), 0)
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(sel1(first(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel1(first(y0, y1), 01)) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), 01)
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(first(y0, y1), s1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel1(first(y0, y1), nil1)) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), nil1)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), s1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), s1(mark(x0)))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), nil1)) → SEL1ACTIVE(unquote1Active(mark(y0)), nil1)
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), 0)) → SEL1ACTIVE(unquote1Active(mark(y0)), 0)
MARK(sel1(unquote1(y0), cons1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), 01)) → SEL1ACTIVE(unquote1Active(mark(y0)), 01)
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), nil)) → SEL1ACTIVE(unquote1Active(mark(y0)), nil)
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), s(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), s(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote1(y0), nil1)) → SEL1ACTIVE(unquote1Active(mark(y0)), nil1)
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), s1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), s1(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), 0)) → SEL1ACTIVE(unquote1Active(mark(y0)), 0)
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(unquote1(y0), s(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), s(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), 01)) → SEL1ACTIVE(unquote1Active(mark(y0)), 01)
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(unquote1(y0), cons1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), nil)) → SEL1ACTIVE(unquote1Active(mark(y0)), nil)

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(from(x1)) → MARK(x1)
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), 0)) → SEL1ACTIVE(s(mark(y0)), 0)
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), s(x0))) → SEL1ACTIVE(s(mark(y0)), s(mark(x0)))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), nil1)) → SEL1ACTIVE(s(mark(y0)), nil1)
MARK(sel1(s(y0), 01)) → SEL1ACTIVE(s(mark(y0)), 01)
MARK(sel1(s(y0), nil)) → SEL1ACTIVE(s(mark(y0)), nil)
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), s1(x0))) → SEL1ACTIVE(s(mark(y0)), s1(mark(x0)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(s(y0), cons1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(s(y0), 01)) → SEL1ACTIVE(s(mark(y0)), 01)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel1(s(y0), 0)) → SEL1ACTIVE(s(mark(y0)), 0)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), s1(x0))) → SEL1ACTIVE(s(mark(y0)), s1(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(s(y0), s(x0))) → SEL1ACTIVE(s(mark(y0)), s(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), nil)) → SEL1ACTIVE(s(mark(y0)), nil)
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), cons1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons1(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), nil1)) → SEL1ACTIVE(s(mark(y0)), nil1)
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(unquote(y0), nil1)) → SEL1ACTIVE(unquoteActive(mark(y0)), nil1)
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), s(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), s(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), 0)) → SEL1ACTIVE(unquoteActive(mark(y0)), 0)
MARK(sel1(unquote(y0), s1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), s1(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), 01)) → SEL1ACTIVE(unquoteActive(mark(y0)), 01)
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(unquote(y0), cons1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), nil)) → SEL1ACTIVE(unquoteActive(mark(y0)), nil)
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), nil)) → SEL1ACTIVE(unquoteActive(mark(y0)), nil)
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), 0)) → SEL1ACTIVE(unquoteActive(mark(y0)), 0)
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote(y0), s1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), s1(mark(x0)))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(unquote(y0), 01)) → SEL1ACTIVE(unquoteActive(mark(y0)), 01)
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), cons1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), s(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), s(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), nil1)) → SEL1ACTIVE(unquoteActive(mark(y0)), nil1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(0, y1)) → SEL1ACTIVE(0, mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(0, s1(x0))) → SEL1ACTIVE(0, s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(0, s(x0))) → SEL1ACTIVE(0, s(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel1(0, cons1(x0, x1))) → SEL1ACTIVE(0, cons1(mark(x0), mark(x1)))
MARK(sel1(0, 01)) → SEL1ACTIVE(0, 01)
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(0, nil)) → SEL1ACTIVE(0, nil)
MARK(sel1(0, 0)) → SEL1ACTIVE(0, 0)
MARK(sel1(0, nil1)) → SEL1ACTIVE(0, nil1)
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, s(x0))) → SEL1ACTIVE(0, s(mark(x0)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, nil1)) → SEL1ACTIVE(0, nil1)
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(0, 0)) → SEL1ACTIVE(0, 0)
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(sel1(0, cons1(x0, x1))) → SEL1ACTIVE(0, cons1(mark(x0), mark(x1)))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(0, 01)) → SEL1ACTIVE(0, 01)
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, nil)) → SEL1ACTIVE(0, nil)
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(0, s1(x0))) → SEL1ACTIVE(0, s1(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(fcons(y0, y1), 0)) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), 0)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(fcons(y0, y1), s1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel1(fcons(y0, y1), nil1)) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), nil1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), 01)) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), 01)
MARK(sel1(fcons(y0, y1), nil)) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), nil)
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), s(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), s(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), s1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), s(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), nil1)) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), nil1)
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel1(fcons(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(fcons(y0, y1), 0)) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), 0)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), 01)) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), 01)
MARK(sel1(fcons(y0, y1), nil)) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), nil)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(from(y0), s1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), s1(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), 01)) → SEL1ACTIVE(fromActive(mark(y0)), 01)
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(from(y0), 0)) → SEL1ACTIVE(fromActive(mark(y0)), 0)
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(from(y0), s(x0))) → SEL1ACTIVE(fromActive(mark(y0)), s(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), nil1)) → SEL1ACTIVE(fromActive(mark(y0)), nil1)
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), cons1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(from(y0), nil)) → SEL1ACTIVE(fromActive(mark(y0)), nil)
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), cons1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(from(y0), s1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), s1(mark(x0)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(from(y0), s(x0))) → SEL1ACTIVE(fromActive(mark(y0)), s(mark(x0)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), 01)) → SEL1ACTIVE(fromActive(mark(y0)), 01)
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(from(y0), nil1)) → SEL1ACTIVE(fromActive(mark(y0)), nil1)
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), 0)) → SEL1ACTIVE(fromActive(mark(y0)), 0)
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), nil)) → SEL1ACTIVE(fromActive(mark(y0)), nil)

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), nil1)) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), nil1)
MARK(sel1(first1(y0, y1), s1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), nil)) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), nil)
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), 01)) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), 01)
MARK(sel1(first1(y0, y1), 0)) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), 0)
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), s(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), nil1)) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), nil1)
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel1(first1(y0, y1), s1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), nil)) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), nil)
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), s(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), 01)) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), 01)
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), 0)) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), 0)
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(first1(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), nil1)) → SEL1ACTIVE(quote1Active(y0), nil1)
MARK(sel1(quote1(y0), nil)) → SEL1ACTIVE(quote1Active(y0), nil)
MARK(sel1(quote1(y0), s(x0))) → SEL1ACTIVE(quote1Active(y0), s(mark(x0)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons1(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), 01)) → SEL1ACTIVE(quote1Active(y0), 01)
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote1(y0), s1(x0))) → SEL1ACTIVE(quote1Active(y0), s1(mark(x0)))
MARK(sel1(quote1(y0), 0)) → SEL1ACTIVE(quote1Active(y0), 0)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(quote1(y0), nil)) → SEL1ACTIVE(quote1Active(y0), nil)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), s(x0))) → SEL1ACTIVE(quote1Active(y0), s(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), 01)) → SEL1ACTIVE(quote1Active(y0), 01)
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(quote1(y0), nil1)) → SEL1ACTIVE(quote1Active(y0), nil1)
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), 0)) → SEL1ACTIVE(quote1Active(y0), 0)
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote1(y0), cons1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons1(mark(x0), mark(x1)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), s1(x0))) → SEL1ACTIVE(quote1Active(y0), s1(mark(x0)))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), s(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(sel1(y0, y1), s1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), nil1)) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), nil1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), nil)) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), nil)
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), 01)) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), 01)
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), 0)) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), 0)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), s(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(sel1(y0, y1), s1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(sel1(y0, y1), 0)) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), 0)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), nil1)) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), nil1)
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(sel1(y0, y1), nil)) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), nil)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), 01)) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), 01)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(sel(y0, y1), 0)) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), 0)
MARK(sel1(sel(y0, y1), s(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), nil1)) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), nil1)
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), s1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel1(sel(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), 01)) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), 01)
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), nil)) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), nil)
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(sel(y0, y1), s(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(sel(y0, y1), s1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), nil)) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), nil)
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel1(sel(y0, y1), 01)) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), 01)
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(sel(y0, y1), 0)) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), 0)
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel1(sel(y0, y1), cons1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(sel(y0, y1), nil1)) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), nil1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(sel1(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1)) at position [1] we obtained the following new rules:

MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), 01)) → SEL1ACTIVE(quoteActive(y0), 01)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), nil1)) → SEL1ACTIVE(quoteActive(y0), nil1)
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote(y0), s1(x0))) → SEL1ACTIVE(quoteActive(y0), s1(mark(x0)))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote(y0), cons1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons1(mark(x0), mark(x1)))
MARK(sel1(quote(y0), s(x0))) → SEL1ACTIVE(quoteActive(y0), s(mark(x0)))
MARK(sel1(quote(y0), 0)) → SEL1ACTIVE(quoteActive(y0), 0)
MARK(sel1(quote(y0), nil)) → SEL1ACTIVE(quoteActive(y0), nil)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(quote(y0), s(x0))) → SEL1ACTIVE(quoteActive(y0), s(mark(x0)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), nil1)) → SEL1ACTIVE(quoteActive(y0), nil1)
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), 0)) → SEL1ACTIVE(quoteActive(y0), 0)
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(y0), s1(x0))) → SEL1ACTIVE(quoteActive(y0), s1(mark(x0)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote(y0), cons1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons1(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), 01)) → SEL1ACTIVE(quoteActive(y0), 01)
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(sel1(quote(y0), nil)) → SEL1ACTIVE(quoteActive(y0), nil)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(quote1(x0), y1)) → FIRST1ACTIVE(quote1Active(x0), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(quote1(y0), s1(x0))) → FIRST1ACTIVE(quote1Active(y0), s1(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(quote1(y0), 0)) → FIRST1ACTIVE(quote1Active(y0), 0)
MARK(first1(quote1(y0), cons1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons1(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), nil1)) → FIRST1ACTIVE(quote1Active(y0), nil1)
MARK(first1(quote1(y0), 01)) → FIRST1ACTIVE(quote1Active(y0), 01)
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), s(x0))) → FIRST1ACTIVE(quote1Active(y0), s(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), nil)) → FIRST1ACTIVE(quote1Active(y0), nil)
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), cons1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons1(mark(x0), mark(x1)))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(quote1(y0), nil1)) → FIRST1ACTIVE(quote1Active(y0), nil1)
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), 01)) → FIRST1ACTIVE(quote1Active(y0), 01)
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(quote1(y0), 0)) → FIRST1ACTIVE(quote1Active(y0), 0)
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(quote1(y0), s(x0))) → FIRST1ACTIVE(quote1Active(y0), s(mark(x0)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first1(quote1(y0), s1(x0))) → FIRST1ACTIVE(quote1Active(y0), s1(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(quote1(y0), nil)) → FIRST1ACTIVE(quote1Active(y0), nil)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(fcons(x0, x1), y1)) → FIRST1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(fcons(y0, y1), s1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(fcons(y0, y1), 0)) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), 0)
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(fcons(y0, y1), nil)) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), nil)
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), nil1)) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), nil1)
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), s(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first1(fcons(y0, y1), 01)) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), 01)
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(fcons(y0, y1), s(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(fcons(y0, y1), nil1)) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), nil1)
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), s1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(fcons(y0, y1), 01)) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), 01)
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(fcons(y0, y1), 0)) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), 0)
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), nil)) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), nil)
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(first1(x0, x1), y1)) → FIRST1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), 0)) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), 0)
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), s1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), nil)) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), nil)
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), nil1)) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), nil1)
MARK(first1(first1(y0, y1), 01)) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), 01)
MARK(first1(first1(y0, y1), s(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), nil1)) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), nil1)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), s1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(first1(first1(y0, y1), 01)) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), 01)
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(first1(first1(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), nil)) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), nil)
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(first1(y0, y1), 0)) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), 0)
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(first1(y0, y1), s(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(from(x0), y1)) → FIRST1ACTIVE(fromActive(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(from(y0), s(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), s(mark(x0)))
MARK(first1(from(y0), nil1)) → FIRST1ACTIVE(fromActive(mark(y0)), nil1)
MARK(first1(from(y0), 01)) → FIRST1ACTIVE(fromActive(mark(y0)), 01)
MARK(first1(from(y0), s1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), s1(mark(x0)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), nil)) → FIRST1ACTIVE(fromActive(mark(y0)), nil)
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(from(y0), cons1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), 0)) → FIRST1ACTIVE(fromActive(mark(y0)), 0)
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(first1(from(y0), 01)) → FIRST1ACTIVE(fromActive(mark(y0)), 01)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(from(y0), nil1)) → FIRST1ACTIVE(fromActive(mark(y0)), nil1)
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), nil)) → FIRST1ACTIVE(fromActive(mark(y0)), nil)
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(from(y0), s(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), s(mark(x0)))
MARK(first1(from(y0), s1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), s1(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), 0)) → FIRST1ACTIVE(fromActive(mark(y0)), 0)
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(s(x0), y1)) → FIRST1ACTIVE(s(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(s(y0), nil1)) → FIRST1ACTIVE(s(mark(y0)), nil1)
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), nil)) → FIRST1ACTIVE(s(mark(y0)), nil)
MARK(first1(s(y0), cons1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first1(s(y0), s(x0))) → FIRST1ACTIVE(s(mark(y0)), s(mark(x0)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(s(y0), 0)) → FIRST1ACTIVE(s(mark(y0)), 0)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), s1(x0))) → FIRST1ACTIVE(s(mark(y0)), s1(mark(x0)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), 01)) → FIRST1ACTIVE(s(mark(y0)), 01)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), nil)) → FIRST1ACTIVE(s(mark(y0)), nil)
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), s(x0))) → FIRST1ACTIVE(s(mark(y0)), s(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(s(y0), nil1)) → FIRST1ACTIVE(s(mark(y0)), nil1)
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(y0), cons1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(first1(s(y0), 0)) → FIRST1ACTIVE(s(mark(y0)), 0)
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(s(y0), s1(x0))) → FIRST1ACTIVE(s(mark(y0)), s1(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), 01)) → FIRST1ACTIVE(s(mark(y0)), 01)
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(sel(x0, x1), y1)) → FIRST1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), 01)) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), 01)
MARK(first1(sel(y0, y1), nil)) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), nil)
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), nil1)) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), nil1)
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(sel(y0, y1), s1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(sel(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), 0)) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), 0)
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), s(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), nil1)) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), nil1)
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(sel(y0, y1), nil)) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), nil)
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), s1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), 0)) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), 0)
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(sel(y0, y1), s(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), 01)) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), 01)
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(first(x0, x1), y1)) → FIRST1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(first(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(first(y0, y1), s1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first(y0, y1), nil1)) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), nil1)
MARK(first1(first(y0, y1), 01)) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), 01)
MARK(first1(first(y0, y1), nil)) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), nil)
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), 0)) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), 0)
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), s(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first(y0, y1), s1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), nil1)) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), nil1)
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), nil)) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), nil)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), 0)) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), 0)
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), 01)) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), 01)
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), s(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), s(mark(x0)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(quote(x0), y1)) → FIRST1ACTIVE(quoteActive(x0), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), s(x0))) → FIRST1ACTIVE(quoteActive(y0), s(mark(x0)))
MARK(first1(quote(y0), nil)) → FIRST1ACTIVE(quoteActive(y0), nil)
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), 01)) → FIRST1ACTIVE(quoteActive(y0), 01)
MARK(first1(quote(y0), 0)) → FIRST1ACTIVE(quoteActive(y0), 0)
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), s1(x0))) → FIRST1ACTIVE(quoteActive(y0), s1(mark(x0)))
MARK(first1(quote(y0), cons1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons1(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote(y0), nil1)) → FIRST1ACTIVE(quoteActive(y0), nil1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(quote(y0), 0)) → FIRST1ACTIVE(quoteActive(y0), 0)
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first1(quote(y0), s1(x0))) → FIRST1ACTIVE(quoteActive(y0), s1(mark(x0)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote(y0), 01)) → FIRST1ACTIVE(quoteActive(y0), 01)
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(quote(y0), nil)) → FIRST1ACTIVE(quoteActive(y0), nil)
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), nil1)) → FIRST1ACTIVE(quoteActive(y0), nil1)
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(first1(quote(y0), s(x0))) → FIRST1ACTIVE(quoteActive(y0), s(mark(x0)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(sel1(x0, x1), y1)) → FIRST1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(sel1(y0, y1), 01)) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), 01)
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(sel1(y0, y1), nil1)) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), nil1)
MARK(first1(sel1(y0, y1), 0)) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), 0)
MARK(first1(sel1(y0, y1), nil)) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), nil)
MARK(first1(sel1(y0, y1), s(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), s1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(sel1(y0, y1), nil)) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), nil)
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first1(sel1(y0, y1), cons1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons1(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), 01)) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), 01)
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(first1(sel1(y0, y1), nil1)) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), nil1)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(sel1(y0, y1), s(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), s(mark(x0)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), s1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), s1(mark(x0)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel1(y0, y1), 0)) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), 0)
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(unquote(x0), y1)) → FIRST1ACTIVE(unquoteActive(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(unquote(y0), first(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), s(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), s(mark(x0)))
MARK(first1(unquote(y0), s1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), s1(mark(x0)))
MARK(first1(unquote(y0), 01)) → FIRST1ACTIVE(unquoteActive(mark(y0)), 01)
MARK(first1(unquote(y0), first1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(unquote(y0), 0)) → FIRST1ACTIVE(unquoteActive(mark(y0)), 0)
MARK(first1(unquote(y0), quote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first1(unquote(y0), unquote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), from(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(unquote(y0), unquote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(unquote(y0), sel(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), cons1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first1(unquote(y0), nil1)) → FIRST1ACTIVE(unquoteActive(mark(y0)), nil1)
MARK(first1(unquote(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote(y0), nil)) → FIRST1ACTIVE(unquoteActive(mark(y0)), nil)
MARK(first1(unquote(y0), cons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote(y0), quote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), from(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), first(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(unquote(y0), unquote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(unquote(y0), s(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), s(mark(x0)))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(unquote(y0), quote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), nil)) → FIRST1ACTIVE(unquoteActive(mark(y0)), nil)
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(unquote(y0), nil1)) → FIRST1ACTIVE(unquoteActive(mark(y0)), nil1)
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), cons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote(y0), s1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), s1(mark(x0)))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), 0)) → FIRST1ACTIVE(unquoteActive(mark(y0)), 0)
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), cons1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons1(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote(y0), 01)) → FIRST1ACTIVE(unquoteActive(mark(y0)), 01)
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(unquote(y0), sel(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(unquote(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), unquote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first1(unquote(y0), quote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote(y0), first1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), from(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(unquote(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), first(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), unquote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(unquote(y0), quote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), cons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(unquote(y0), sel(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(unquote(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), unquote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(unquote(y0), quote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote(y0), first1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(first1(unquote1(x0), y1)) → FIRST1ACTIVE(unquote1Active(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(first1(unquote1(y0), s(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), s(mark(x0)))
MARK(first1(unquote1(y0), quote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(unquote1(y0), s1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), s1(mark(x0)))
MARK(first1(unquote1(y0), cons1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), 0)) → FIRST1ACTIVE(unquote1Active(mark(y0)), 0)
MARK(first1(unquote1(y0), quote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(y0), cons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), first(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), nil1)) → FIRST1ACTIVE(unquote1Active(mark(y0)), nil1)
MARK(first1(unquote1(y0), from(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first1(unquote1(y0), 01)) → FIRST1ACTIVE(unquote1Active(mark(y0)), 01)
MARK(first1(unquote1(y0), sel(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), unquote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), first1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), nil)) → FIRST1ACTIVE(unquote1Active(mark(y0)), nil)
MARK(first1(unquote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), unquote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), from(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(unquote1(y0), s1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), s1(mark(x0)))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), quote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(unquote1(y0), cons1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), cons1(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(unquote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), quote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(unquote1(y0), 0)) → FIRST1ACTIVE(unquote1Active(mark(y0)), 0)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), first(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(unquote(y0), unquote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), first1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(unquote(y0), quote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), cons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), cons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), 01)) → FIRST1ACTIVE(unquote1Active(mark(y0)), 01)
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(first1(unquote1(y0), unquote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), nil)) → FIRST1ACTIVE(unquote1Active(mark(y0)), nil)
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), sel(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(unquote1(y0), first(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), sel(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), s(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), s(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), unquote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), unquote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), from(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote(y0), quote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), first1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), nil1)) → FIRST1ACTIVE(unquote1Active(mark(y0)), nil1)
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), from(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(unquote(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), quote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(unquote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), quote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), first(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), unquote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), first1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(unquote(y0), quote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), cons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), cons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(first1(unquote1(y0), unquote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), sel(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(unquote1(y0), first(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(unquote(y0), sel(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(unquote(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), unquote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), unquote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(unquote1(y0), from(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(unquote(y0), quote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote(y0), first1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule UNQUOTEACTIVE(s1(X)) → UNQUOTEACTIVE(mark(X)) at position [0] we obtained the following new rules:

UNQUOTEACTIVE(s1(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
UNQUOTEACTIVE(s1(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(cons1(x0, x1))) → UNQUOTEACTIVE(cons1(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(s(x0))) → UNQUOTEACTIVE(s(mark(x0)))
UNQUOTEACTIVE(s1(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
UNQUOTEACTIVE(s1(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
UNQUOTEACTIVE(s1(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(01)) → UNQUOTEACTIVE(01)
UNQUOTEACTIVE(s1(nil1)) → UNQUOTEACTIVE(nil1)
UNQUOTEACTIVE(s1(0)) → UNQUOTEACTIVE(0)
UNQUOTEACTIVE(s1(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
UNQUOTEACTIVE(s1(nil)) → UNQUOTEACTIVE(nil)
UNQUOTEACTIVE(s1(cons(x0, x1))) → UNQUOTEACTIVE(cons(mark(x0), x1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(cons(x0, x1))) → UNQUOTEACTIVE(cons(mark(x0), x1))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), from(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
UNQUOTEACTIVE(s1(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), quote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(unquote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(first1(unquote1(y0), quote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
UNQUOTEACTIVE(s1(nil1)) → UNQUOTEACTIVE(nil1)
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(unquote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), first(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(unquote(y0), unquote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(unquote1(y0), first1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(cons1(x0, x1))) → UNQUOTEACTIVE(cons1(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(first1(unquote(y0), quote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), cons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
UNQUOTEACTIVE(s1(01)) → UNQUOTEACTIVE(01)
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), cons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), unquote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(unquote1(y0), sel(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
UNQUOTEACTIVE(s1(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(unquote1(y0), first(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), sel(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
UNQUOTEACTIVE(s1(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), unquote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(unquote1(y0), unquote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
UNQUOTEACTIVE(s1(nil)) → UNQUOTEACTIVE(nil)
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(unquote1(y0), from(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
UNQUOTEACTIVE(s1(0)) → UNQUOTEACTIVE(0)
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote(y0), quote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
UNQUOTEACTIVE(s1(s(x0))) → UNQUOTEACTIVE(s(mark(x0)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(s1(x1)) → MARK(x1)
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(x1, x2)) → MARK(x1)
UNQUOTEACTIVE(s1(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), first1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
UNQUOTEACTIVE(s1(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(first(sel1(y0, y1), unquote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
SEL1ACTIVE(0, cons(X, Z)) → QUOTEACTIVE(X)
UNQUOTEACTIVE(s1(X)) → MARK(X)
MARK(sel1(quote(y0), cons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote(x0))) → FIRST1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(sel1(s(y0), sel1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), cons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(quote1(y0), first1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), unquote(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(sel(y0, y1), quote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), quote1(x0))) → SEL1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel1(quote1(y0), quote(x0))) → SEL1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(sel1(unquote(y0), quote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first(x0, x1))) → FIRSTACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(quote1(y0), sel1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), sel1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel1(x0, x1))) → SELACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → SELACTIVE(mark(X), mark(Z))
QUOTEACTIVE(sel(0, y1)) → SEL1ACTIVE(0, mark(y1))
MARK(sel(first1(y0, y1), cons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(from(x0), y1)) → SEL1ACTIVE(fromActive(mark(x0)), mark(y1))
MARK(first(first1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), first1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x2)
MARK(sel(0, sel(x0, x1))) → SELACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), first1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), first(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(unquote1(x0))) → UNQUOTE1ACTIVE(unquote1Active(mark(x0)))
MARK(sel1(sel1(y0, y1), quote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), sel(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), from(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(quote(y0), sel(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(unquote1(cons1(x0, x1))) → UNQUOTE1ACTIVE(cons1(mark(x0), mark(x1)))
MARK(sel(0, from(x0))) → SELACTIVE(0, fromActive(mark(x0)))
MARK(first(s(y0), quote(x0))) → FIRSTACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(first1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(unquote(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(first1(y0, y1), quote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(quote(y0), sel1(x0, x1))) → SELACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), quote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel1(s(y0), sel(x0, x1))) → SEL1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), cons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(fcons(x1, x2)) → MARK(x2)
MARK(first(s(y0), fcons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote1(x0))) → SEL1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), cons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(x1, x2)) → MARK(x1)
MARK(sel(quote1(y0), first1(x0, x1))) → SELACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), from(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), first1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(unquote(y0), quote(x0))) → SELACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), first1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(sel(s(y0), quote(x0))) → SELACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(unquote1(y0), cons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(s(y0), quote1(x0))) → SELACTIVE(s(mark(y0)), quote1Active(x0))
MARK(first(fcons(y0, y1), cons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(quote(x1)) → QUOTEACTIVE(x1)
MARK(sel1(sel1(y0, y1), unquote1(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), sel1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → QUOTEACTIVE(Y)
MARK(first(unquote1(y0), unquote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(first(quote(y0), quote(x0))) → FIRSTACTIVE(quoteActive(y0), quoteActive(x0))
UNQUOTEACTIVE(s1(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(first1(sel1(y0, y1), from(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(s(y0), unquote(x0))) → SELACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(from(y0), quote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(unquote(y0), cons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote(x0))) → SELACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(sel1(quote1(y0), quote1(x0))) → SEL1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel(fcons(y0, y1), unquote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), fcons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(from(y0), quote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), sel1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), quote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(first(y0, y1), quote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), sel(x0, x1))) → SEL1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(0, quote(x0))) → SELACTIVE(0, quoteActive(x0))
MARK(first1(quote(y0), from(x0))) → FIRST1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(from(y0), fcons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), from(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(first1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(quote1(y0), cons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first1(quote(y0), sel1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), cons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), sel(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(from(y0), quote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel1(first1(y0, y1), quote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(from(y0), quote1(x0))) → SELACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(s(y0), fcons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote1(y0), from(x0))) → FIRSTACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first1(sel1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(first1(quote(y0), unquote(x0))) → FIRST1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → MARK(x1)
MARK(sel1(0, sel1(x0, x1))) → SEL1ACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), from(x0))) → SELACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel(quote1(y0), cons(x0, x1))) → SELACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(first1(y0, y1), sel(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first1(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), unquote1(x0))) → SELACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), unquote1(x0))) → FIRSTACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(unquote1(first1(x0, x1))) → UNQUOTE1ACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), first1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(sel1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), cons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(s(y0), sel(x0, x1))) → FIRSTACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), unquote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, unquote(x0))) → SELACTIVE(0, unquoteActive(mark(x0)))
MARK(first(unquote1(y0), cons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(first1(y0, y1), unquote(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), first1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), first(x0, x1))) → FIRSTACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x1)
MARK(sel(first(y0, y1), sel1(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), cons(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), sel1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), fcons(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(from(x1)) → MARK(x1)
MARK(sel(sel(y0, y1), quote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote(y0), from(x0))) → SEL1ACTIVE(quoteActive(y0), fromActive(mark(x0)))
MARK(sel1(quote(y0), first(x0, x1))) → SEL1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), quote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), unquote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(fcons(y0, y1), first1(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), fcons(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote(y0), first(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), first(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), from(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(unquote1(y0), unquote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → FCONSACTIVE(unquoteActive(mark(X)), unquote1Active(mark(Z)))
MARK(first(quote(y0), sel1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), fcons(x0, x1))) → SELACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(from(x0))) → UNQUOTEACTIVE(fromActive(mark(x0)))
MARK(unquote(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), from(x0))) → SEL1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
MARK(first(first(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), first(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), quote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(sel1(y0, y1), quote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first(fcons(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), first1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), cons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(first1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), quote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(fcons(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), unquote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(s(y0), cons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(first(y0, y1), first(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
UNQUOTEACTIVE(s1(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), unquote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), first(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote1(quote(x0))) → UNQUOTE1ACTIVE(quoteActive(x0))
MARK(sel(from(y0), from(x0))) → SELACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(from(y0), sel(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), from(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(unquote1(from(x0))) → UNQUOTE1ACTIVE(fromActive(mark(x0)))
MARK(sel1(s(y0), quote1(x0))) → SEL1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s(x1)) → MARK(x1)
MARK(unquote(x1)) → MARK(x1)
QUOTE1ACTIVE(first(X, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(sel(y0, y1), quote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(first(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(unquote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), unquote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), sel(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → SEL1ACTIVE(mark(X), mark(Z))
MARK(sel1(quote(y0), unquote1(x0))) → SEL1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), cons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(sel1(quote(y0), fcons(x0, x1))) → SEL1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel(s(y0), fcons(x0, x1))) → SELACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(quote1(y0), quote1(x0))) → SELACTIVE(quote1Active(y0), quote1Active(x0))
FROMACTIVE(X) → MARK(X)
QUOTEACTIVE(sel(sel1(x0, x1), y1)) → SEL1ACTIVE(sel1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel1(fcons(y0, y1), unquote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), fcons(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
SELACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote1(y0), unquote(x0))) → SELACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(first1(sel1(y0, y1), quote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote1(y0), quote1(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel1(sel1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), fcons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(unquote(x0), y1)) → SEL1ACTIVE(unquoteActive(mark(x0)), mark(y1))
MARK(sel1(s(y0), first1(x0, x1))) → SEL1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), from(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), first(x0, x1))) → SELACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(0, unquote1(x0))) → SEL1ACTIVE(0, unquote1Active(mark(x0)))
QUOTEACTIVE(sel(first1(x0, x1), y1)) → SEL1ACTIVE(first1Active(mark(x0), mark(x1)), mark(y1))
MARK(sel(sel(y0, y1), sel1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), sel(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote1(y0), unquote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), unquote1(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, quote(x0))) → SEL1ACTIVE(0, quoteActive(x0))
MARK(sel1(s(y0), fcons(x0, x1))) → SEL1ACTIVE(s(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), quote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(unquote(unquote1(x0))) → UNQUOTEACTIVE(unquote1Active(mark(x0)))
MARK(sel(first(y0, y1), fcons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), first(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), from(x0))) → FIRST1ACTIVE(quote1Active(y0), fromActive(mark(x0)))
QUOTE1ACTIVE(first(X, Z)) → MARK(Z)
MARK(first1(first1(y0, y1), quote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(from(y0), first1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), from(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first(y0, y1), cons(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
QUOTEACTIVE(sel(quote(x0), y1)) → SEL1ACTIVE(quoteActive(x0), mark(y1))
MARK(sel(first(y0, y1), first(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first1(x0, x1))) → SEL1ACTIVE(quote1Active(y0), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), cons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), unquote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(sel1(s(y0), unquote1(x0))) → SEL1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(sel(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel(y0, y1), unquote(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(s(y0), unquote1(x0))) → FIRSTACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(sel(y0, y1), first(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), sel(x0, x1))) → SELACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), quote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(first(y0, y1), quote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(first(y0, y1), quote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first1(x0, x1))) → SELACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), quote1(x0))) → FIRSTACTIVE(s(mark(y0)), quote1Active(x0))
MARK(sel1(first1(y0, y1), first(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), cons(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(sel1(y0, y1), first(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(unquote1(first(x0, x1))) → UNQUOTE1ACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), first(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(sel1(y0, y1), cons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(0, unquote(x0))) → SEL1ACTIVE(0, unquoteActive(mark(x0)))
MARK(sel(first(y0, y1), unquote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(unquote1(y0), first(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), unquote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), first1(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote1(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel(x0, x1))) → SELACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), unquote1(x0))) → FIRST1ACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first(quote(y0), from(x0))) → FIRSTACTIVE(quoteActive(y0), fromActive(mark(x0)))
FIRSTACTIVE(s(X), cons(Y, Z)) → MARK(Y)
MARK(sel(unquote1(y0), first1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), unquote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel1(first1(y0, y1), unquote1(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(sel(sel1(y0, y1), quote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(unquote1(y0), first1(x0, x1))) → SEL1ACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), quote1(x0))) → FIRST1ACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first1(quote1(y0), quote(x0))) → FIRST1ACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(s(y0), unquote(x0))) → FIRST1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
MARK(first(fcons(y0, y1), quote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(quote(y0), sel(x0, x1))) → SEL1ACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(Z)
MARK(sel(quote(y0), cons(x0, x1))) → SELACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel1(unquote1(y0), quote(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quoteActive(x0))
MARK(first1(fcons(y0, y1), quote(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first1(unquote(y0), quote(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), quote1(x0))) → FIRSTACTIVE(quote1Active(y0), quote1Active(x0))
MARK(unquote(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), unquote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first1(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), first1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(first(x0, x1), y1)) → SEL1ACTIVE(firstActive(mark(x0), mark(x1)), mark(y1))
MARK(sel1(sel1(y0, y1), from(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel1(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), sel1(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), from(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), unquote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), sel1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(quote(y0), unquote(x0))) → SELACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), cons(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), cons(mark(x0), x1))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTE1ACTIVE(mark(Z))
MARK(unquote1(fcons(x0, x1))) → UNQUOTE1ACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(quote1(x1)) → QUOTE1ACTIVE(x1)
MARK(sel1(fcons(y0, y1), quote1(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(fcons(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), quote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(first(quote1(y0), unquote(x0))) → FIRSTACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel1(first1(y0, y1), quote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(quote1(y0), fcons(x0, x1))) → FIRSTACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), sel(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), quote1(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote(y0), quote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), quote(x0))) → SELACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(s(y0), from(x0))) → SELACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(sel1(from(y0), unquote1(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), from(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
QUOTEACTIVE(sel(s(x0), y1)) → SEL1ACTIVE(s(mark(x0)), mark(y1))
MARK(unquote(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(first1(sel1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(first(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote1(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(fcons(y0, y1), first(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(unquote1(y0), fcons(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), first(x0, x1))) → SEL1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(unquote(y0), cons(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel1(x0, x1))) → FIRSTACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), first1(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(quote(y0), cons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), cons(mark(x0), x1))
MARK(sel(fcons(y0, y1), cons(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), fcons(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), from(x0))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel1(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(s(y0), quote(x0))) → SEL1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(sel1(sel1(y0, y1), sel1(x0, x1))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, quote1(x0))) → SEL1ACTIVE(0, quote1Active(x0))
MARK(first1(unquote1(y0), unquote1(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote1(y0), sel1(x0, x1))) → SELACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote(y0), first1(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(unquote(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(s(y0), cons(x0, x1))) → SELACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first(quote1(y0), sel(x0, x1))) → FIRSTACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), unquote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(unquote(x0))) → UNQUOTEACTIVE(unquoteActive(mark(x0)))
MARK(sel(unquote(y0), fcons(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(quote(y0), first1(x0, x1))) → FIRSTACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(quote(y0), sel1(x0, x1))) → SEL1ACTIVE(quoteActive(y0), sel1Active(mark(x0), mark(x1)))
MARK(first(first1(y0, y1), quote1(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(sel1(y0, y1), cons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), first1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), from(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(0, cons(x0, x1))) → SEL1ACTIVE(0, cons(mark(x0), x1))
MARK(sel(quote(y0), first(x0, x1))) → SELACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), from(x0))) → SEL1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first(s(y0), first1(x0, x1))) → FIRSTACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first(from(y0), fcons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), from(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
UNQUOTE1ACTIVE(cons1(X, Z)) → UNQUOTEACTIVE(mark(X))
MARK(sel(s(y0), unquote1(x0))) → SELACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote1(x0))) → SELACTIVE(quoteActive(y0), quote1Active(x0))
MARK(sel(quote1(y0), quote(x0))) → SELACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(sel1(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel1(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), sel1Active(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(0, fcons(x0, x1))) → SEL1ACTIVE(0, fconsActive(mark(x0), mark(x1)))
QUOTEACTIVE(s(X)) → QUOTEACTIVE(X)
MARK(first1(sel1(y0, y1), quote1(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), first1(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), sel(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
SELACTIVE(0, cons(X, Z)) → MARK(X)
MARK(sel(quote(y0), unquote1(x0))) → SELACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
MARK(first(from(y0), first(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), from(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(sel(y0, y1), first(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), sel(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), cons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), cons(mark(x0), x1))
MARK(first(sel1(y0, y1), quote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
QUOTEACTIVE(sel(unquote1(x0), y1)) → SEL1ACTIVE(unquote1Active(mark(x0)), mark(y1))
MARK(first1(from(y0), first1(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), from(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(first1(y0, y1), quote1(x0))) → SELACTIVE(first1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(unquote(x0))) → UNQUOTE1ACTIVE(unquoteActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
MARK(sel(fcons(y0, y1), quote(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(first(y0, y1), quote1(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first1(s(y0), sel1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(0, first(x0, x1))) → SEL1ACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(Z)
MARK(sel(quote(y0), first1(x0, x1))) → SELACTIVE(quoteActive(y0), first1Active(mark(x0), mark(x1)))
MARK(sel1(unquote(y0), unquote(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote1(y0), sel(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), unquote1(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(unquote1(quote1(x0))) → UNQUOTE1ACTIVE(quote1Active(x0))
MARK(first1(quote1(y0), fcons(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(first1(x1, x2)) → MARK(x2)
MARK(first(first(y0, y1), sel(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), first(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(from(y0), from(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(first(y0, y1), unquote1(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), first(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(s(y0), from(x0))) → FIRST1ACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(first1(unquote1(y0), first(x0, x1))) → FIRST1ACTIVE(unquote1Active(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), unquote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(first(x0, x1))) → UNQUOTEACTIVE(firstActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), fcons(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), quote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(0, unquote1(x0))) → SELACTIVE(0, unquote1Active(mark(x0)))
MARK(first(s(y0), from(x0))) → FIRSTACTIVE(s(mark(y0)), fromActive(mark(x0)))
MARK(unquote(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), first1(x0, x1))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), quote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), quote1Active(x0))
MARK(first1(quote1(y0), unquote(x0))) → FIRST1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(unquote1(x1)) → MARK(x1)
MARK(first1(sel(y0, y1), quote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel(sel(y0, y1), fcons(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), sel(x0, x1))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), first(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel(0, quote1(x0))) → SELACTIVE(0, quote1Active(x0))
MARK(first1(unquote(y0), sel(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), unquote(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(x1, x2)) → MARK(x2)
MARK(first1(unquote(y0), sel1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first1(sel1(y0, y1), unquote(x0))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), sel(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), from(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), first(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(unquote(s1(x0))) → UNQUOTEACTIVE(s1(mark(x0)))
MARK(first1(quote1(y0), quote1(x0))) → FIRST1ACTIVE(quote1Active(y0), quote1Active(x0))
MARK(sel1(quote(y0), unquote(x0))) → SEL1ACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel1(0, sel(x0, x1))) → SEL1ACTIVE(0, selActive(mark(x0), mark(x1)))
MARK(sel1(first1(y0, y1), first1(x0, x1))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
SEL1ACTIVE(s(X), cons(Y, Z)) → MARK(X)
MARK(sel1(first(y0, y1), cons(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel(from(y0), sel1(x0, x1))) → SELACTIVE(fromActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), from(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), fromActive(mark(x0)))
QUOTEACTIVE(sel(sel(x0, x1), y1)) → SEL1ACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
UNQUOTEACTIVE(s1(sel(x0, x1))) → UNQUOTEACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first(sel(y0, y1), unquote(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first1(s(y0), unquote1(x0))) → FIRST1ACTIVE(s(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(0, first1(x0, x1))) → SEL1ACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(sel(fcons(y0, y1), quote1(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), from(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel1(from(y0), sel(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel1(from(y0), from(x0))) → SEL1ACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(first(sel(y0, y1), cons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(first1(from(y0), quote(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), quoteActive(x0))
MARK(sel(sel(y0, y1), from(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(fcons(y0, y1), from(x0))) → SELACTIVE(fconsActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(sel(from(y0), sel(x0, x1))) → SELACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(sel(from(y0), fcons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(unquote(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(first(first1(y0, y1), quote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(from(y0), cons(x0, x1))) → SEL1ACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(sel(y0, y1), unquote(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(unquote1(y0), unquote(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(first1(unquote(y0), unquote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(0, fcons(x0, x1))) → SELACTIVE(0, fconsActive(mark(x0), mark(x1)))
MARK(first(unquote(y0), quote(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), quoteActive(x0))
MARK(sel(sel1(y0, y1), unquote(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), sel1(x0, x1))) → SELACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), first(x0, x1))) → SEL1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(s(y0), first(x0, x1))) → FIRSTACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), unquote(x0))) → SEL1ACTIVE(quote1Active(y0), unquoteActive(mark(x0)))
MARK(sel(from(y0), unquote(x0))) → SELACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTEACTIVE(X)
MARK(sel(unquote(y0), from(x0))) → SELACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first1(unquote1(y0), from(x0))) → FIRST1ACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(first1(from(y0), unquote1(x0))) → FIRST1ACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel(quote(y0), quote(x0))) → SELACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(first(y0, y1), cons(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), cons(mark(x0), x1))
MARK(sel1(from(y0), unquote(x0))) → SEL1ACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), from(x0))) → SEL1ACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(sel1(quote(y0), quote(x0))) → SEL1ACTIVE(quoteActive(y0), quoteActive(x0))
MARK(first(unquote(y0), first(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), unquote(x0))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(fcons(x1, x2)) → FCONSACTIVE(mark(x1), mark(x2))
QUOTEACTIVE(sel(fcons(x0, x1), y1)) → SEL1ACTIVE(fconsActive(mark(x0), mark(x1)), mark(y1))
MARK(sel(0, first1(x0, x1))) → SELACTIVE(0, first1Active(mark(x0), mark(x1)))
MARK(first(s(y0), unquote(x0))) → FIRSTACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
QUOTEACTIVE(sel(quote1(x0), y1)) → SEL1ACTIVE(quote1Active(x0), mark(y1))
MARK(first1(sel1(y0, y1), first(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(first(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(from(y0), unquote1(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), from(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel1(first(y0, y1), quote1(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(unquote1(y0), from(x0))) → SELACTIVE(unquote1Active(mark(y0)), fromActive(mark(x0)))
MARK(sel(from(y0), unquote1(x0))) → SELACTIVE(fromActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first1(unquote(y0), quote1(x0))) → FIRST1ACTIVE(unquoteActive(mark(y0)), quote1Active(x0))
MARK(sel(from(y0), cons(x0, x1))) → SELACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(sel(x1, x2)) → MARK(x2)
QUOTE1ACTIVE(first(X, Z)) → MARK(X)
MARK(sel1(first1(y0, y1), unquote(x0))) → SEL1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), first1(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(s(y0), cons(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(sel1(fcons(y0, y1), unquote(x0))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel1(unquote(y0), fcons(x0, x1))) → SEL1ACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), quote1(x0))) → SELACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(sel(first1(y0, y1), first1(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), quote1(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel(s(y0), first(x0, x1))) → SELACTIVE(s(mark(y0)), firstActive(mark(x0), mark(x1)))
MARK(sel1(quote1(y0), cons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), cons(mark(x0), x1))
MARK(first(quote1(y0), unquote1(x0))) → FIRSTACTIVE(quote1Active(y0), unquote1Active(mark(x0)))
MARK(first1(quote1(y0), first(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(first(quote(y0), unquote(x0))) → FIRSTACTIVE(quoteActive(y0), unquoteActive(mark(x0)))
MARK(sel(0, first(x0, x1))) → SELACTIVE(0, firstActive(mark(x0), mark(x1)))
MARK(sel(first(y0, y1), quote(x0))) → SELACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(first(unquote(y0), unquote1(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), unquote(x0))) → FIRSTACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(quote(y0), sel(x0, x1))) → SELACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote(x0))) → FIRST1ACTIVE(s(mark(y0)), quoteActive(x0))
MARK(first(sel(y0, y1), unquote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(first(unquote1(y0), sel(x0, x1))) → FIRSTACTIVE(unquote1Active(mark(y0)), selActive(mark(x0), mark(x1)))
FCONSACTIVE(X, Z) → MARK(X)
MARK(first1(sel1(y0, y1), fcons(x0, x1))) → FIRST1ACTIVE(sel1Active(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first1(fcons(y0, y1), sel1(x0, x1))) → FIRST1ACTIVE(fconsActive(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel(y0, y1), first1(x0, x1))) → SELACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(sel(first1(y0, y1), sel(x0, x1))) → SELACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(s(y0), sel(x0, x1))) → SELACTIVE(s(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(s(y0), quote1(x0))) → FIRST1ACTIVE(s(mark(y0)), quote1Active(x0))
MARK(s1(x1)) → MARK(x1)
MARK(sel1(x1, x2)) → MARK(x1)
UNQUOTEACTIVE(s1(quote(x0))) → UNQUOTEACTIVE(quoteActive(x0))
MARK(sel(quote1(y0), fcons(x0, x1))) → SELACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), quote(x0))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(0, from(x0))) → SEL1ACTIVE(0, fromActive(mark(x0)))
MARK(first(sel(y0, y1), quote1(x0))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(sel1(sel(y0, y1), fcons(x0, x1))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(sel1(fcons(y0, y1), sel(x0, x1))) → SEL1ACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(unquote1(y0), sel1(x0, x1))) → SELACTIVE(unquote1Active(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(sel(sel1(y0, y1), unquote1(x0))) → SELACTIVE(sel1Active(mark(y0), mark(y1)), unquote1Active(mark(x0)))
MARK(from(x1)) → FROMACTIVE(mark(x1))
MARK(first1(sel(y0, y1), from(x0))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), fromActive(mark(x0)))
MARK(first1(from(y0), sel(x0, x1))) → FIRST1ACTIVE(fromActive(mark(y0)), selActive(mark(x0), mark(x1)))
MARK(first1(quote1(y0), sel(x0, x1))) → FIRST1ACTIVE(quote1Active(y0), selActive(mark(x0), mark(x1)))
QUOTE1ACTIVE(cons(X, Z)) → QUOTE1ACTIVE(Z)
MARK(first1(s(y0), first1(x0, x1))) → FIRST1ACTIVE(s(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first1(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
QUOTEACTIVE(sel(X, Z)) → MARK(X)
MARK(sel(unquote1(y0), unquote(x0))) → SELACTIVE(unquote1Active(mark(y0)), unquoteActive(mark(x0)))
MARK(sel(unquote(y0), unquote1(x0))) → SELACTIVE(unquoteActive(mark(y0)), unquote1Active(mark(x0)))
MARK(sel1(unquote1(y0), quote1(x0))) → SEL1ACTIVE(unquote1Active(mark(y0)), quote1Active(x0))
MARK(first1(first(y0, y1), sel(x0, x1))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(first1(sel(y0, y1), first(x0, x1))) → FIRST1ACTIVE(selActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(sel1(s(y0), unquote(x0))) → SEL1ACTIVE(s(mark(y0)), unquoteActive(mark(x0)))
UNQUOTEACTIVE(s1(first1(x0, x1))) → UNQUOTEACTIVE(first1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), first(x0, x1))) → SELACTIVE(quote1Active(y0), firstActive(mark(x0), mark(x1)))
MARK(sel1(sel(y0, y1), quote1(x0))) → SEL1ACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(from(y0), unquote(x0))) → FIRSTACTIVE(fromActive(mark(y0)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), from(x0))) → FIRSTACTIVE(unquoteActive(mark(y0)), fromActive(mark(x0)))
MARK(first(quote(y0), quote1(x0))) → FIRSTACTIVE(quoteActive(y0), quote1Active(x0))
MARK(first(quote1(y0), quote(x0))) → FIRSTACTIVE(quote1Active(y0), quoteActive(x0))
MARK(first1(quote(y0), first(x0, x1))) → FIRST1ACTIVE(quoteActive(y0), firstActive(mark(x0), mark(x1)))
FIRST1ACTIVE(s(X), cons(Y, Z)) → FIRST1ACTIVE(mark(X), mark(Z))
MARK(first(from(y0), cons(x0, x1))) → FIRSTACTIVE(fromActive(mark(y0)), cons(mark(x0), x1))
MARK(first(first1(y0, y1), unquote(x0))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(unquote(y0), first1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(unquote1(sel1(x0, x1))) → UNQUOTE1ACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(unquote(fcons(x0, x1))) → UNQUOTEACTIVE(fconsActive(mark(x0), mark(x1)))
MARK(cons1(x1, x2)) → MARK(x2)
MARK(first1(first(y0, y1), quote1(x0))) → FIRST1ACTIVE(firstActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(first(sel(y0, y1), fcons(x0, x1))) → FIRSTACTIVE(selActive(mark(y0), mark(y1)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), sel(x0, x1))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), selActive(mark(x0), mark(x1)))
MARK(sel(0, cons(x0, x1))) → SELACTIVE(0, cons(mark(x0), x1))
MARK(first(unquote(y0), fcons(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), fconsActive(mark(x0), mark(x1)))
MARK(first(fcons(y0, y1), unquote(x0))) → FIRSTACTIVE(fconsActive(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(sel(sel(y0, y1), quote1(x0))) → SELACTIVE(selActive(mark(y0), mark(y1)), quote1Active(x0))
MARK(unquote1(sel(x0, x1))) → UNQUOTE1ACTIVE(selActive(mark(x0), mark(x1)))
MARK(first(x1, x2)) → MARK(x1)
MARK(first(quote(y0), sel(x0, x1))) → FIRSTACTIVE(quoteActive(y0), selActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(X)
MARK(first(sel1(y0, y1), sel1(x0, x1))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), sel1Active(mark(x0), mark(x1)))
MARK(first(s(y0), cons(x0, x1))) → FIRSTACTIVE(s(mark(y0)), cons(mark(x0), x1))
MARK(first1(unquote(y0), first1(x0, x1))) → FIRST1ACTIVE(unquoteActive(mark(y0)), first1Active(mark(x0), mark(x1)))
MARK(first1(first1(y0, y1), unquote(x0))) → FIRST1ACTIVE(first1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))
MARK(first(from(y0), from(x0))) → FIRSTACTIVE(fromActive(mark(y0)), fromActive(mark(x0)))
MARK(sel(0, sel1(x0, x1))) → SELACTIVE(0, sel1Active(mark(x0), mark(x1)))
MARK(sel(quote1(y0), from(x0))) → SELACTIVE(quote1Active(y0), fromActive(mark(x0)))
UNQUOTEACTIVE(s1(sel1(x0, x1))) → UNQUOTEACTIVE(sel1Active(mark(x0), mark(x1)))
MARK(first(quote(y0), fcons(x0, x1))) → FIRSTACTIVE(quoteActive(y0), fconsActive(mark(x0), mark(x1)))
MARK(sel1(first(y0, y1), first(x0, x1))) → SEL1ACTIVE(firstActive(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first1(quote(y0), unquote1(x0))) → FIRST1ACTIVE(quoteActive(y0), unquote1Active(mark(x0)))
UNQUOTEACTIVE(s1(quote1(x0))) → UNQUOTEACTIVE(quote1Active(x0))
MARK(sel1(sel1(y0, y1), quote(x0))) → SEL1ACTIVE(sel1Active(mark(y0), mark(y1)), quoteActive(x0))
MARK(sel1(quote1(y0), fcons(x0, x1))) → SEL1ACTIVE(quote1Active(y0), fconsActive(mark(x0), mark(x1)))
UNQUOTE1ACTIVE(cons1(X, Z)) → MARK(Z)
MARK(first(first1(y0, y1), first(x0, x1))) → FIRSTACTIVE(first1Active(mark(y0), mark(y1)), firstActive(mark(x0), mark(x1)))
MARK(first(first(y0, y1), first1(x0, x1))) → FIRSTACTIVE(firstActive(mark(y0), mark(y1)), first1Active(mark(x0), mark(x1)))
MARK(first(unquote(y0), sel1(x0, x1))) → FIRSTACTIVE(unquoteActive(mark(y0)), sel1Active(mark(x0), mark(x1)))
MARK(first(sel1(y0, y1), unquote(x0))) → FIRSTACTIVE(sel1Active(mark(y0), mark(y1)), unquoteActive(mark(x0)))

The TRS R consists of the following rules:

mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(first(x1, x2)) → firstActive(mark(x1), mark(x2))
firstActive(x1, x2) → first(x1, x2)
mark(from(x1)) → fromActive(mark(x1))
fromActive(x1) → from(x1)
mark(sel1(x1, x2)) → sel1Active(mark(x1), mark(x2))
sel1Active(x1, x2) → sel1(x1, x2)
mark(first1(x1, x2)) → first1Active(mark(x1), mark(x2))
first1Active(x1, x2) → first1(x1, x2)
mark(quote(x1)) → quoteActive(x1)
quoteActive(x1) → quote(x1)
mark(quote1(x1)) → quote1Active(x1)
quote1Active(x1) → quote1(x1)
mark(unquote(x1)) → unquoteActive(mark(x1))
unquoteActive(x1) → unquote(x1)
mark(unquote1(x1)) → unquote1Active(mark(x1))
unquote1Active(x1) → unquote1(x1)
mark(fcons(x1, x2)) → fconsActive(mark(x1), mark(x2))
fconsActive(x1, x2) → fcons(x1, x2)
mark(s(x1)) → s(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(nil) → nil
mark(nil1) → nil1
mark(cons1(x1, x2)) → cons1(mark(x1), mark(x2))
mark(01) → 01
mark(s1(x1)) → s1(mark(x1))
selActive(s(X), cons(Y, Z)) → selActive(mark(X), mark(Z))
selActive(0, cons(X, Z)) → mark(X)
firstActive(0, Z) → nil
firstActive(s(X), cons(Y, Z)) → cons(mark(Y), first(X, Z))
fromActive(X) → cons(mark(X), from(s(X)))
sel1Active(s(X), cons(Y, Z)) → sel1Active(mark(X), mark(Z))
sel1Active(0, cons(X, Z)) → quoteActive(X)
first1Active(0, Z) → nil1
first1Active(s(X), cons(Y, Z)) → cons1(quoteActive(Y), first1Active(mark(X), mark(Z)))
quoteActive(0) → 01
quote1Active(cons(X, Z)) → cons1(quoteActive(X), quote1Active(Z))
quote1Active(nil) → nil1
quoteActive(s(X)) → s1(quoteActive(X))
quoteActive(sel(X, Z)) → sel1Active(mark(X), mark(Z))
quote1Active(first(X, Z)) → first1Active(mark(X), mark(Z))
unquoteActive(01) → 0
unquoteActive(s1(X)) → s(unquoteActive(mark(X)))
unquote1Active(nil1) → nil
unquote1Active(cons1(X, Z)) → fconsActive(unquoteActive(mark(X)), unquote1Active(mark(Z)))
fconsActive(X, Z) → cons(mark(X), Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We applied the Trivial transformation to transform the context-sensitive TRS to a usual TRS.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → FCONS(unquote(X), unquote1(Z))
UNQUOTE1(cons1(X, Z)) → UNQUOTE(X)
SEL(s(X), cons(Y, Z)) → SEL(X, Z)
FROM(X) → FROM(s(X))
QUOTE(s(X)) → QUOTE(X)
FIRST(s(X), cons(Y, Z)) → FIRST(X, Z)
FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)
UNQUOTE(s1(X)) → UNQUOTE(X)
FIRST1(s(X), cons(Y, Z)) → QUOTE(Y)
QUOTE1(cons(X, Z)) → QUOTE1(Z)
QUOTE1(cons(X, Z)) → QUOTE(X)
UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)
QUOTE(sel(X, Z)) → SEL1(X, Z)
SEL1(s(X), cons(Y, Z)) → SEL1(X, Z)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE1(first(X, Z)) → FIRST1(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → FCONS(unquote(X), unquote1(Z))
UNQUOTE1(cons1(X, Z)) → UNQUOTE(X)
SEL(s(X), cons(Y, Z)) → SEL(X, Z)
FROM(X) → FROM(s(X))
QUOTE(s(X)) → QUOTE(X)
FIRST(s(X), cons(Y, Z)) → FIRST(X, Z)
FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)
UNQUOTE(s1(X)) → UNQUOTE(X)
FIRST1(s(X), cons(Y, Z)) → QUOTE(Y)
QUOTE1(cons(X, Z)) → QUOTE1(Z)
QUOTE1(cons(X, Z)) → QUOTE(X)
UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)
QUOTE(sel(X, Z)) → SEL1(X, Z)
SEL1(s(X), cons(Y, Z)) → SEL1(X, Z)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE1(first(X, Z)) → FIRST1(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 8 SCCs with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ MNOCProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [15] to enlarge Q to all left-hand sides of R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

R is empty.
The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [15] to enlarge Q to all left-hand sides of R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

R is empty.
The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(sel(X, Z)) → SEL1(X, Z)
SEL1(s(X), cons(Y, Z)) → SEL1(X, Z)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(s(X)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(sel(X, Z)) → SEL1(X, Z)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(X), cons(Y, Z)) → SEL1(X, Z)
QUOTE(s(X)) → QUOTE(X)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [15] to enlarge Q to all left-hand sides of R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)

R is empty.
The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST1(s(X), cons(Y, Z)) → FIRST1(X, Z)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(cons(X, Z)) → QUOTE1(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [15] to enlarge Q to all left-hand sides of R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(cons(X, Z)) → QUOTE1(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(cons(X, Z)) → QUOTE1(Z)

R is empty.
The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(cons(X, Z)) → QUOTE1(Z)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM(X) → FROM(s(X))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [15] to enlarge Q to all left-hand sides of R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM(X) → FROM(s(X))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM(X) → FROM(s(X))

R is empty.
The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM(X) → FROM(s(X))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST(s(X), cons(Y, Z)) → FIRST(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [15] to enlarge Q to all left-hand sides of R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST(s(X), cons(Y, Z)) → FIRST(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST(s(X), cons(Y, Z)) → FIRST(X, Z)

R is empty.
The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST(s(X), cons(Y, Z)) → FIRST(X, Z)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof

Q DP problem:
The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → SEL(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [15] to enlarge Q to all left-hand sides of R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → SEL(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, Z)
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, first(X, Z))
from(X) → cons(X, from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, Z)
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, Z))
quote(0) → 01
quote1(cons(X, Z)) → cons1(quote(X), quote1(Z))
quote1(nil) → nil1
quote(s(X)) → s1(quote(X))
quote(sel(X, Z)) → sel1(X, Z)
quote1(first(X, Z)) → first1(X, Z)
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)

The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → SEL(X, Z)

R is empty.
The set Q consists of the following terms:

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

sel(s(x0), cons(x1, x2))
sel(0, cons(x0, x1))
first(0, x0)
first(s(x0), cons(x1, x2))
from(x0)
sel1(s(x0), cons(x1, x2))
sel1(0, cons(x0, x1))
first1(0, x0)
first1(s(x0), cons(x1, x2))
quote(0)
quote1(cons(x0, x1))
quote1(nil)
quote(s(x0))
quote(sel(x0, x1))
quote1(first(x0, x1))
unquote(01)
unquote(s1(x0))
unquote1(nil1)
unquote1(cons1(x0, x1))
fcons(x0, x1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ MNOCProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → SEL(X, Z)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: